home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / Magazine / GraphicsCards / StormMesa / src / FX / fxquads.c < prev    next >
C/C++ Source or Header  |  1999-02-04  |  8KB  |  300 lines
  1. /* -*- mode: C; tab-width:8;  -*-
  2.  
  3.              fxquads.c - 3Dfx VooDoo quad functions 
  4. */
  5.  
  6. /*
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Library General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Library General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Library General Public
  18.  * License along with this library; if not, write to the Free
  19.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.  *
  21.  * See the file fxapi.c for more informations about authors
  22.  *
  23.  */
  24.  
  25. #if defined(FX)
  26.  
  27. #include "fxdrv.h"
  28.  
  29. /************************************************************************/
  30. /************************* Quads functions ******************************/
  31. /************************************************************************/
  32.  
  33. #define GOURAUD(v) { \
  34.   fxMesa->gWin[(v)].r=(float) VB->Color[(v)][0]; \
  35.   fxMesa->gWin[(v)].g=(float) VB->Color[(v)][1]; \
  36.   fxMesa->gWin[(v)].b=(float) VB->Color[(v)][2]; \
  37.   fxMesa->gWin[(v)].a=(float) VB->Color[(v)][3]; \
  38. }
  39.  
  40. /************************************************************************/
  41.  
  42. static void fxQuadSmooth(GLcontext *ctx, GLuint v1, GLuint v2,
  43.              GLuint v3, GLuint v4, GLuint pv)
  44. {
  45.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  46.   GrVertex *grv2,*grv4;
  47.  
  48.   grv2=&fxMesa->gWin[v2];
  49.   grv4=&fxMesa->gWin[v4];
  50.  
  51.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  52.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  53. }
  54.  
  55. static void fxQuadSmoothTwoSide(GLcontext *ctx, GLuint v1, GLuint v2,
  56.                 GLuint v3, GLuint v4, GLuint pv)
  57. {
  58.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  59.   struct vertex_buffer *VB=ctx->VB;
  60.   GrVertex *grv2,*grv4;
  61.  
  62.   GOURAUD(v1); 
  63.   GOURAUD(v2); 
  64.   GOURAUD(v3); 
  65.   GOURAUD(v4); 
  66.  
  67.   grv2=&fxMesa->gWin[v2];
  68.   grv4=&fxMesa->gWin[v4];
  69.  
  70.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  71.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  72. }
  73.  
  74. static void fxQuadFlat(GLcontext *ctx, GLuint v1, GLuint v2,
  75.                GLuint v3,GLuint v4, GLuint pv)
  76. {
  77.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  78.   GLubyte *Color=ctx->VB->Color[pv];
  79.   GrVertex *grv2,*grv4;
  80.  
  81.   grConstantColorValue(FXCOLOR(Color[0], Color[1], Color[2], Color[3]));
  82.  
  83.   grv2=&fxMesa->gWin[v2];
  84.   grv4=&fxMesa->gWin[v4];
  85.  
  86.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  87.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  88. }
  89.  
  90. /************************************************************************/
  91.  
  92. static void fxQuadSmoothFrontBack(GLcontext *ctx, GLuint v1, GLuint v2,
  93.                   GLuint v3, GLuint v4, GLuint pv)
  94. {
  95.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  96.   GrVertex *grv2,*grv4;
  97.  
  98.   grv2=&fxMesa->gWin[v2];
  99.   grv4=&fxMesa->gWin[v4];
  100.  
  101.   if(ctx->Color.ColorMask)
  102.     grColorMask(FXTRUE,FXFALSE);
  103.   else
  104.     grColorMask(FXFALSE,FXFALSE);
  105.   grDepthMask(FXFALSE);
  106.   grRenderBuffer(GR_BUFFER_BACKBUFFER);
  107.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  108.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  109.  
  110.   if(ctx->Color.ColorMask)
  111.     grColorMask(FXTRUE,fxMesa->haveAlphaBuffer ? FXTRUE : FXFALSE);
  112.   else
  113.     grColorMask(FXFALSE,FXFALSE);
  114.   if(ctx->Depth.Mask)
  115.     grDepthMask(FXTRUE);
  116.   grRenderBuffer(GR_BUFFER_FRONTBUFFER);
  117.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  118.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  119. }
  120.  
  121. static void fxQuadSmoothTwoSideFrontBack(GLcontext *ctx, GLuint v1, GLuint v2,
  122.                      GLuint v3, GLuint v4, GLuint pv)
  123. {
  124.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  125.   struct vertex_buffer *VB=ctx->VB;
  126.   GrVertex *grv2,*grv4;
  127.  
  128.   GOURAUD(v1); 
  129.   GOURAUD(v2); 
  130.   GOURAUD(v3); 
  131.   GOURAUD(v4); 
  132.  
  133.   grv2=&fxMesa->gWin[v2];
  134.   grv4=&fxMesa->gWin[v4];
  135.  
  136.   if(ctx->Color.ColorMask)
  137.     grColorMask(FXTRUE,FXFALSE);
  138.   else
  139.     grColorMask(FXFALSE,FXFALSE);
  140.   grDepthMask(FXFALSE);
  141.   grRenderBuffer(GR_BUFFER_BACKBUFFER);
  142.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  143.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  144.  
  145.   if(ctx->Color.ColorMask)
  146.     grColorMask(FXTRUE,fxMesa->haveAlphaBuffer ? FXTRUE : FXFALSE);
  147.   else
  148.     grColorMask(FXFALSE,FXFALSE);
  149.   if(ctx->Depth.Mask)
  150.     grDepthMask(FXTRUE);
  151.   grRenderBuffer(GR_BUFFER_FRONTBUFFER);
  152.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  153.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  154. }
  155.  
  156. static void fxQuadFlatFrontBack(GLcontext *ctx, GLuint v1, GLuint v2,
  157.                 GLuint v3,GLuint v4, GLuint pv)
  158. {
  159.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  160.   GLubyte *Color=ctx->VB->Color[pv];
  161.   GrVertex *grv2,*grv4;
  162.  
  163.   grConstantColorValue(FXCOLOR(Color[0], Color[1], Color[2], Color[3]));
  164.  
  165.   grv2=&fxMesa->gWin[v2];
  166.   grv4=&fxMesa->gWin[v4];
  167.  
  168.   if(ctx->Color.ColorMask)
  169.     grColorMask(FXTRUE,FXFALSE);
  170.   else
  171.     grColorMask(FXFALSE,FXFALSE);
  172.   grDepthMask(FXFALSE);
  173.   grRenderBuffer(GR_BUFFER_BACKBUFFER);
  174.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  175.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  176.  
  177.   if(ctx->Color.ColorMask)
  178.     grColorMask(FXTRUE,fxMesa->haveAlphaBuffer ? FXTRUE : FXFALSE);
  179.   else
  180.     grColorMask(FXFALSE,FXFALSE);
  181.   if(ctx->Depth.Mask)
  182.     grDepthMask(FXTRUE);
  183.   grRenderBuffer(GR_BUFFER_FRONTBUFFER);
  184.   grDrawTriangle(&fxMesa->gWin[v1], grv2, grv4);
  185.   grDrawTriangle(grv2, &fxMesa->gWin[v3], grv4);
  186. }
  187.  
  188. /************************************************************************/
  189.  
  190. static void fxAAQuadSmooth(GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4, GLuint pv)
  191. {
  192.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  193.   GrVertex *grv2,*grv4;
  194.  
  195.   grv2=&fxMesa->gWin[v2];
  196.   grv4=&fxMesa->gWin[v4];
  197.  
  198.   grAADrawTriangle(&fxMesa->gWin[v1],grv2,grv4,
  199.            FXTRUE,FXFALSE,FXFALSE);
  200.   grAADrawTriangle(grv2,&fxMesa->gWin[v3],grv4,
  201.            FXTRUE,FXTRUE,FXFALSE);
  202. }
  203.  
  204. static void fxAAQuadSmoothTwoSide(GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4, GLuint pv)
  205. {
  206.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  207.   struct vertex_buffer *VB=ctx->VB;
  208.   GrVertex *grv2,*grv4;
  209.  
  210.   GOURAUD(v1); 
  211.   GOURAUD(v2); 
  212.   GOURAUD(v3); 
  213.   GOURAUD(v4); 
  214.  
  215.   grv2=&fxMesa->gWin[v2];
  216.   grv4=&fxMesa->gWin[v4];
  217.  
  218.   grAADrawTriangle(&fxMesa->gWin[v1],grv2,grv4,
  219.            FXTRUE,FXFALSE,FXTRUE);
  220.   grAADrawTriangle(grv2,&fxMesa->gWin[v3],grv4,
  221.            FXTRUE,FXTRUE,FXFALSE);
  222. }
  223.  
  224. static void fxAAQuadFlat(GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3,GLuint v4, GLuint pv)
  225. {
  226.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  227.   GLubyte *Color=ctx->VB->Color[pv];
  228.   GrVertex *grv2,*grv4;
  229.  
  230.   grConstantColorValue(FXCOLOR(Color[0],Color[1],
  231.                    Color[2],Color[3]));
  232.  
  233.   fxMesa->gWin[v1].a=fxMesa->gWin[v2].a=fxMesa->gWin[v3].a=fxMesa->gWin[v4].a=(float)Color[3];
  234.  
  235.   grv2=&fxMesa->gWin[v2];
  236.   grv4=&fxMesa->gWin[v4];
  237.  
  238.   grAADrawTriangle(&fxMesa->gWin[v1],grv2,grv4,
  239.            FXTRUE,FXFALSE,FXTRUE);
  240.   grAADrawTriangle(grv2,&fxMesa->gWin[v3],grv4,
  241.            FXTRUE,FXTRUE,FXFALSE);
  242. }
  243.  
  244. /************************************************************************/
  245.  
  246. quad_func fxDDChooseQuadFunction(GLcontext *ctx)
  247. {
  248.   fxMesaContext fxMesa=(fxMesaContext)ctx->DriverCtx;
  249.  
  250.   if((ctx->Polygon.OffsetAny) || /* Not yet supported */
  251.      (ctx->Polygon.StippleFlag))
  252.     return NULL;
  253.  
  254.   if(ctx->Polygon.SmoothFlag) {
  255.     if(ctx->Light.ShadeModel==GL_SMOOTH) {
  256.       if(ctx->Light.Model.TwoSide)
  257.     return fxAAQuadSmoothTwoSide;
  258.  
  259.       return fxAAQuadSmooth;
  260.     }
  261.  
  262.     return fxAAQuadFlat;
  263.   }
  264.  
  265.   if(ctx->RasterMask & FRONT_AND_BACK_BIT) {
  266.     if(ctx->Light.ShadeModel==GL_SMOOTH) {
  267.       if(ctx->Light.Model.TwoSide)
  268.     return fxQuadSmoothTwoSideFrontBack;
  269.  
  270.       return fxQuadSmoothFrontBack;
  271.     }
  272.  
  273.     return fxQuadFlatFrontBack;
  274.   }
  275.  
  276.   if(ctx->Light.ShadeModel==GL_SMOOTH) {
  277.     if(ctx->Light.Model.TwoSide)
  278.       return fxQuadSmoothTwoSide;
  279.  
  280.     return fxQuadSmooth;
  281.   }
  282.  
  283.   return fxQuadFlat;
  284. }
  285.  
  286.  
  287. #else
  288.  
  289.  
  290. /*
  291.  * Need this to provide at least one external definition.
  292.  */
  293.  
  294. int gl_fx_dummy_function_quads(void)
  295. {
  296.   return 0;
  297. }
  298.  
  299. #endif  /* FX */
  300.